home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 247_01 / big.hpp < prev    next >
Text File  |  1989-04-17  |  9KB  |  197 lines
  1. /*
  2.  *    Experimental MIRACL  C++ Header file
  3.  *
  4.  *    AUTHOR  :    N.Coghlan
  5.  *                 Modified by M.Scott
  6.  *    NAME    :    big.hpp
  7.  *             
  8.  *    PURPOSE :    Definition of class Big
  9.  */
  10.  
  11. overload pow;
  12. overload sqrt;
  13. overload abs;
  14.  
  15. overload prime;
  16. overload gcd;
  17. overload root;
  18. overload inverse;
  19. overload rand;
  20.  
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <math.h>
  24. #include "miracl.h"
  25.  
  26. class miracl
  27. { /* dummy class to initialise MIRACL */
  28. public:
  29.     miracl(int nd,small nb=MAXBASE) {mirsys(nd,nb);STROUT=TRUE;POINT=TRUE;}
  30. };
  31.  
  32. class Big 
  33. { 
  34.     big fn;
  35. public:
  36.     Big()                                               { fn = mirvar(0); } 
  37.     Big(int i)                                          { fn = mirvar(i); }
  38.     Big(long lg)                         { fn = mirvar(0); lconv(lg,fn);  }
  39.     Big(Big& b)                          { fn = mirvar(0); copy(b.fn,fn); }
  40.     Big(char* s)           {fn=mirvar(0);strcpy(IBUFF,s);cinnum(fn,stdin);}
  41.  
  42.     Big& operator=(int i)                    {convert(i,fn); return *this;}
  43.     Big& operator=(const Big& b)             {copy(b.fn,fn); return *this;}
  44.     Big& operator=(char* s){strcpy(IBUFF,s);cinnum(fn,stdin);return *this;}
  45.  
  46.     Big& operator++()                        {incr(fn,1,fn); return *this;}
  47.     Big& operator--()                        {decr(fn,1,fn); return *this;}
  48.     Big& operator+=(int i)                   {incr(fn,i,fn); return *this;}
  49.     Big& operator+=(const Big& b)          {add(fn,b.fn,fn); return *this;}
  50.  
  51.     Big& operator-=(int i)                   {decr(fn,i,fn); return *this;}
  52.     Big& operator-=(const Big& b)     {subtract(fn,b.fn,fn); return *this;}
  53.  
  54.     Big& operator*=(int i)                {premult(fn,i,fn); return *this;}
  55.     Big& operator*=(const Big& b)     {multiply(fn,b.fn,fn); return *this;}
  56.  
  57.     Big& operator/=(int i)              {subdiv(fn,i,fn);    return *this;}
  58.     Big& operator/=(const Big& b)       {divide(fn,b.fn,fn); return *this;}
  59.  
  60.     Big& operator%=(int i)     {convert(subdiv(fn,i,fn),fn); return *this;}
  61.     Big& operator%=(const Big& b)     {divide(fn,b.fn,b.fn); return *this;}
  62.  
  63.     friend Big operator-(const Big&);
  64.  
  65.     friend Big operator+(const Big&,int);
  66.     friend Big operator+(int,const Big&);
  67.     friend Big operator+(const Big&, const Big&);
  68.  
  69.     friend Big operator-(const Big&, int);
  70.     friend Big operator-(int,const Big&);
  71.     friend Big operator-(const Big&, const Big&);
  72.  
  73.     friend Big operator*(const Big&, int);
  74.     friend Big operator*(int,const Big&);
  75.     friend Big operator*(const Big&, const Big&);
  76.  
  77.     friend Big operator/(const Big&, int);
  78.     friend Big operator/(int,const Big&);
  79.     friend Big operator/(const Big&, const Big&);
  80.  
  81.     friend int operator%(const Big&, int);
  82.     friend Big operator%(const Big&, const Big&);
  83.  
  84.     friend bool operator<=(const Big& b1, const Big& b2)
  85.              {if (compare(b1.fn,b2.fn)<=0) return TRUE; else return FALSE;}
  86.     friend bool operator<=(const Big&,int);
  87.     friend bool operator<=(int,const Big&);
  88.  
  89.     friend bool operator>=(const Big& b1, const Big& b2)
  90.              {if (compare(b1.fn,b2.fn)>=0) return TRUE; else return FALSE;}
  91.     friend bool operator>=(const Big&,int);
  92.     friend bool operator>=(int,const Big&);
  93.     
  94.     friend bool operator==(const Big& b1, const Big& b2)
  95.              {if (compare(b1.fn,b2.fn)==0) return TRUE; else return FALSE;}
  96.     friend bool operator==(const Big&,int);
  97.     friend bool operator==(int,const Big&);
  98.  
  99.     friend bool operator!=(const Big& b1, const Big& b2)
  100.              {if (compare(b1.fn,b2.fn)!=0) return TRUE; else return FALSE;}
  101.     friend bool operator!=(const Big&, int);
  102.     friend bool operator!=(int, const Big&);
  103.  
  104.     friend bool operator<(const Big& b1, const Big& b2)
  105.               {if (compare(b1.fn,b2.fn)<0) return TRUE; else return FALSE;}
  106.     friend bool operator<(const Big&, int);
  107.     friend bool operator<(int, const Big&);
  108.  
  109.     friend bool operator>(const Big& b1, const Big& b2)
  110.               {if (compare(b1.fn,b2.fn)>0) return TRUE; else return FALSE;}
  111.     friend bool operator>(const Big&, int);
  112.     friend bool operator>(int, const Big&);
  113.  
  114.     friend Big sqrt(const Big&);
  115.     friend Big abs(const Big&);
  116.     friend bool prime(const Big& b)                   {return prime(b.fn);}
  117.     friend Big gcd(const Big&, const Big &);
  118.     friend Big pow(const Big&,int);
  119.     friend Big pow(const Big&, int, const Big&);
  120.     friend Big pow(const Big&, const Big&, const Big&);
  121.     friend Big inverse(const Big&, int);
  122.     friend Big inverse(const Big&, const Big&);
  123.     friend Big root(const Big&, int);
  124.     friend Big rand(const Big&);
  125.     friend istream& operator>>(istream& s, Big& x)
  126.                            { s >> IBUFF; cinnum(x.fn,stdin) ;   return s; }
  127.     friend ostream& operator<<(ostream& s, Big& x)
  128.                  { cotnum(x.fn,stdout); if (STROUT) s << OBUFF;  return s;}
  129.  
  130.     ~Big() {free((char *)fn); }
  131. };
  132.  
  133. Big operator-(const Big& b)   {Big nb; negate(b.fn,nb.fn); return nb;}
  134. Big operator+(const Big& b,int i)
  135.                               {Big abi; incr(b.fn, i, abi.fn); return abi;}
  136. Big operator+(int i,const Big& b)
  137.                               {Big aib; incr(b.fn, i, aib.fn); return aib;}
  138. Big operator+(const Big& b1, const Big& b2)
  139.                               {Big abb;add(b1.fn,b2.fn,abb.fn);return abb;}
  140.  
  141. Big operator-(const Big& b, int i)
  142.                               {Big mbi; decr(b.fn, i, mbi.fn); return mbi;}
  143. Big operator-(int i,const Big& b)
  144.           {Big mib;decr(b.fn, i, mib.fn);negate(mib.fn,mib.fn);return mib;}
  145. Big operator-(const Big& b1, const Big& b2)
  146.                        {Big mbb; subtract(b1.fn,b2.fn,mbb.fn); return mbb;}
  147.  
  148. Big operator*(const Big& b, int i)
  149.                            {Big xbi; premult(b.fn, i, xbi.fn); return xbi;}
  150. Big operator*(int i,const Big& b)
  151.                            {Big xib; premult(b.fn, i, xib.fn); return xib;}
  152. Big operator*(const Big& b1, const Big& b2)
  153.                        {Big xbb; multiply(b1.fn,b2.fn,xbb.fn); return xbb;}
  154.  
  155. Big operator/(const Big& b, int i)
  156.                             {Big dbi; subdiv(b.fn, i, dbi.fn); return dbi;}
  157. Big operator/(int i,const Big& b)
  158.          {Big dib;convert(i,dib.fn);divide(dib.fn,b.fn,dib.fn);return dib;}
  159. Big operator/(const Big& b1, const Big& b2)
  160.                          {Big dbb; divide(b1.fn,b2.fn,dbb.fn); return dbb;}
  161.  
  162. int operator%(const Big& b, int i)
  163.                                {Big mdbi; return(subdiv(b.fn,i, mdbi.fn));}
  164. Big operator%(const Big& b1, const Big& b2)
  165.                      {Big mdbb=b1;divide(mdbb.fn,b2.fn,b2.fn);return mdbb;}
  166. Big sqrt(const Big& b)              {Big z; root(b.fn, 2, z.fn); return z;}
  167. Big abs(const Big& b)               {Big z; absol(b.fn,z.fn);    return z;}
  168. Big gcd(const Big& b1,const Big& b2){Big z;gcd(b1.fn,b2.fn,z.fn);return z;}
  169. Big pow(const Big& b,int n)     {Big z; power(b.fn,n,z.fn,z.fn); return z;}
  170. Big pow(const Big& b1,int n,const Big& b3)
  171.                               {Big z; power(b1.fn,n,b3.fn,z.fn); return z;}
  172. Big pow(const Big& b1,const Big& b2,const Big& b3)
  173.                          {Big z; powmod(b1.fn,b2.fn,b3.fn,z.fn); return z;}
  174. Big inverse(const Big& b1,const Big& b2)
  175.                         {Big z; xgcd(b1.fn,b2.fn,z.fn,z.fn,z.fn);return z;}
  176. Big inverse(const Big& b,int n)
  177.                         {Big z=n; xgcd(b.fn,z.fn,z.fn,z.fn,z.fn);return z;}
  178. Big root(const Big& b,int n)          {Big z; root(b.fn,n,z.fn); return z;}
  179. Big rand(const Big& b)               {Big z; bigrand(b.fn,z.fn); return z;}
  180.  
  181.  
  182.  
  183. bool operator<=(const Big& b, int i)              {Big z=i; return (b<=z);}
  184. bool operator<=(int i, const Big& b)              {Big z=i; return (z<=b);}
  185. bool operator>=(const Big& b, int i)              {Big z=i; return (b>=z);}
  186. bool operator>=(int i, const Big& b)              {Big z=i; return (z>=b);}
  187. bool operator==(const Big& b, int i)              {Big z=i; return (b==z);}
  188. bool operator==(int i, const Big& b)              {Big z=i; return (z==b);}
  189. bool operator!=(const Big& b, int i)